package com.cdsxt.util;

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;
import java.util.Arrays;
import java.util.Date;
import java.util.HashSet;
import java.util.Set;

/**
 * 文件操作数据的工具类
 * 
 * 读取文件的数据
 * copy文件的数据
 * 分割文件
 * 合并文件
 * ...
 */
public class FileUtil {

	
	

	/**
	 * 创建文件夹
	 */
	public static boolean mkdirs(String path) {
		File file=new File(path);
		return file.mkdirs();
	}
	
	
	/**
	 * 创建指定大小的随机内容文件到指定位置
	 * path：指定位置
	 * size：大小（m为单位）
	 */
	public static void createFile(String path,long size) {

//	     a）创建数据源
		File file=new File(path);
		OutputStream fos=null;
//	     b）通过数据源创建需要的输出流
		try {
			fos=new FileOutputStream(file);
//		     c）创建要写出的数据
//		     d）通过流把数据写到对应的数据源
			byte [] temp= new byte[1024*1024];
			for (int i = 0; i < size; i++) {
				//写出 1m数据
				fos.write(temp);
			}
//		    e）刷新流flush（如果需要数据-立即传入到数据源时，则需要调用）
			fos.flush();
			System.out.println("写出数据完成");
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
//		     f）关闭流close
			IoCloseUtil.close(fos);
		}
	
	}
	
	/**
	 * copy 字节文件的功能-没有缓冲区
	 * oldPath 原文件路径
	 * newPath 新文件路径
	 */
	public static void copyByteFileNoBuffer(String oldPath,String newPath){
		//1）创建输入输出数据源
		File fileIn=new File(oldPath);
		File fileOut=new File(newPath);
		InputStream fis=null;
		OutputStream fos=null;
		//2）创建输入输出管道
		try {
			fis=new FileInputStream(fileIn);
			fos=new FileOutputStream(fileOut);
			//3）通过输入管道读取数据
			//缓冲数组
			byte[] buff=new byte[64];
			int len;
			long startDate=new Date().getTime();
			while ((len=fis.read(buff))!=-1) {
				//4）通过输出管道写出数据
				fos.write(buff, 0, len);
			}
			//5）通过输出管道刷新数据
			fos.flush();
			long endDate=new Date().getTime();
			
			//	System.out.println("没有缓冲区copy完成-用时："+(endDate-startDate));
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			//6）关闭所有的管道-先开打后关闭
			IoCloseUtil.close(fos,fis);
		}
	}
	public static void writeStringDataToFile(String filePath,String charSetName,String data){
		Writer osw=null;
		try {
			File file=new File(filePath);
			osw= new OutputStreamWriter(new FileOutputStream(file), charSetName);
			//写出数据
			osw.write(data);
			//刷新
			osw.flush();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
//			 * 5）关闭管道
			IoCloseUtil.close(osw);
		}
	}
	public static void writeByteArrDataToFile(String filePath,byte[] data){
		OutputStream osw=null;
		try {
			File file=new File(filePath);
			osw= new FileOutputStream(file);
			//写出数据
			osw.write(data);
			//刷新
			osw.flush();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
//			 * 5）关闭管道
			IoCloseUtil.close(osw);
		}
	}
	/**
	 * 读取字符文件的数据
	 * 按行读取-每一行作为一个字符串装入set容器中
	 */
	public static Set<String> readFileInfoToSet(String filePath,String charSetName){
		BufferedReader br=null;
		try {
//			 * 1）创建数据源
			File file=new File(filePath);
//			 * 2）根据数据源连接建立输入管道-流
			//a)创建连接到文件的字节输入流
			//b)创建处理流（转换流）把字节流转换字符流，并设置解码的字符集
			br= new BufferedReader(new InputStreamReader(new FileInputStream(file), charSetName))  ;
//			 * 3）通过输入管道-读取数据
			//缓存数据-字符串
			String buff;
			//装字符串的set
			Set<String> set=new HashSet<String>();
			while ((buff=br.readLine())!=null) {//1）读取数据,存储数据 2）存储长度3）判断有数据
				//4)处理数据
				set.add(buff);
			}
			//返回
			return set;
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
//			 * 5）关闭管道
			IoCloseUtil.close(br);
		}
		return null;
	}
	
	/**
	 * 读取字符文件数据到程序中返回为字符串
	 */
	//参数：path文件的路径
	//charSetName 字符集
	//返回值：文件的存储的字符数据
	public static String readCharFileInfo(String path,String charSetName) {
		//a）创建输入数据源
		File file=new File(path);
		//b）创建输入管道
		InputStream fis=null;
		Reader isr=null;
		try {
			
			//创建节点流-文件字节输入流=连接到文件
			fis=new FileInputStream(file);
			
			//创建转换流-包装字节输入流-转换为字符输入流
			isr=new InputStreamReader(fis, charSetName);
			
			//c）通过输入管道读取数据
			//连接的字符串
			StringBuilder sb=new StringBuilder();
			
			char [] buff=new char[512];
			int len;
			while ((len=isr.read(buff))!=-1) {
				//d）处理数据
				//System.out.println("读取的字符："+Arrays.toString(buff));
				sb.append(buff, 0, len);
			}
			//返回数据
			return sb.toString();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			//e）关闭管道-先打开后关闭
			IoCloseUtil.close(isr,fis);
		}
		//报错-返回null
		return null;
	}
}
